Integratsioonitestimine: API testimise valdamine Supertestiga

Tarkvaraarenduse valdkonnas on ülioluline tagada, et üksikud komponendid töötaksid eraldi õigesti (ühikutestimine). Siiski on sama tähtis kontrollida, et need komponendid töötaksid sujuvalt koos. Siin tulebki mängu integratsioonitestimine. Integratsioonitestimine keskendub rakenduse erinevate moodulite või teenuste vahelise interaktsiooni valideerimisele. See artikkel süveneb integratsioonitestimisse, keskendudes spetsiifiliselt API testimisele Supertestiga, mis on võimas ja kasutajasõbralik teek HTTP-päringute testimiseks Node.js-is.

Mis on integratsioonitestimine?

Integratsioonitestimine on tarkvara testimise tüüp, mis kombineerib üksikuid tarkvaramooduleid ja testib neid grupina. Selle eesmärk on paljastada defekte integreeritud üksuste vahelistes interaktsioonides. Erinevalt ühikutestimisest, mis keskendub üksikutele komponentidele, kontrollib integratsioonitestimine andmevoogu ja kontrollvoogu moodulite vahel. Levinumad integratsioonitestimise lähenemisviisid on:

• Ülalt-alla integratsioon: Alustatakse kõrgeima taseme moodulitest ja integreeritakse allapoole.
• Alt-üles integratsioon: Alustatakse madalaima taseme moodulitest ja integreeritakse ülespoole.
• Suure paugu integratsioon: Kõikide moodulite samaaegne integreerimine. See lähenemine on üldiselt vähem soovitatav probleemide isoleerimise raskuse tõttu.
• Võileiva integratsioon: Ülalt-alla ja alt-üles integratsiooni kombinatsioon.

API-de kontekstis hõlmab integratsioonitestimine kontrollimist, kas erinevad API-d töötavad korrektselt koos, kas nende vahel edastatavad andmed on järjepidevad ja kas kogu süsteem toimib ootuspäraselt. Kujutage näiteks ette e-kaubanduse rakendust, millel on eraldi API-d tootehalduseks, kasutajate autentimiseks ja maksete töötlemiseks. Integratsioonitestimine tagaks, et need API-d suhtlevad korrektselt, võimaldades kasutajatel tooteid sirvida, turvaliselt sisse logida ja oste sooritada.

Miks on API integratsioonitestimine oluline?

API integratsioonitestimine on kriitilise tähtsusega mitmel põhjusel:

• Tagab süsteemi usaldusväärsuse: See aitab tuvastada integratsiooniprobleeme arendustsükli varajases staadiumis, vältides ootamatuid tõrkeid tootmiskeskkonnas.
• Valideerib andmete terviklikkuse: See kontrollib, et andmeid edastatakse ja teisendatakse korrektselt erinevate API-de vahel.
• Parandab rakenduse jõudlust: See võib paljastada API interaktsioonidega seotud jõudluse kitsaskohti.
• Suurendab turvalisust: See võib tuvastada turvanõrkusi, mis tulenevad ebaõigest API integratsioonist. Näiteks tagades korrektse autentimise ja autoriseerimise API-de suhtlemisel.
• Vähendab arenduskulusid: Integratsiooniprobleemide varajane parandamine on oluliselt odavam kui nendega tegelemine arendustsükli hilisemas etapis.

Mõelge globaalsele reisibroneerimisplatvormile. API integratsioonitestimine on ülimalt oluline, et tagada sujuv suhtlus erinevatest riikidest pärit lennubroneeringuid, hotellibroneeringuid ja makselüüse käsitlevate API-de vahel. Nende API-de ebaõige integreerimine võib põhjustada valesid broneeringuid, maksetõrkeid ja halba kasutajakogemust, mõjutades negatiivselt platvormi mainet ja tulusid.

Tutvustame Supertesti: võimas tööriist API testimiseks

Supertest on kõrgetasemeline abstraktsioon HTTP-päringute testimiseks. See pakub mugavat ja sujuvat API-d päringute saatmiseks teie rakendusele ja vastuste kontrollimiseks. Node.js-i peale ehitatud Supertest on spetsiaalselt loodud Node.js HTTP-serverite testimiseks. See töötab erakordselt hästi populaarsete testimisraamistikega nagu Jest ja Mocha.

Supertesti peamised omadused:

• Lihtne kasutada: Supertest pakub lihtsat ja intuitiivset API-d HTTP-päringute saatmiseks ja kinnituste tegemiseks.
• Asünkroonne testimine: See käsitleb sujuvalt asünkroonseid operatsioone, muutes selle ideaalseks asünkroonsel loogikal põhinevate API-de testimiseks.
• Sujuv liides: See pakub sujuvat liidest, mis võimaldab meetodeid aheldada, et testid oleksid lühikesed ja loetavad.
• Laiaulatuslik kinnituste tugi: See toetab laia valikut kinnitusi vastuse olekukoodide, päiste ja kehade kontrollimiseks.
• Integratsioon testimisraamistikega: See integreerub sujuvalt populaarsete testimisraamistikega nagu Jest ja Mocha, võimaldades teil kasutada oma olemasolevat testimisinfrastruktuuri.

Testimiskeskkonna seadistamine

Enne alustamist seadistame põhilise testimiskeskkonna. Eeldame, et teil on installitud Node.js ja npm (või yarn). Kasutame testimisraamistikuna Jesti ja API testimiseks Supertesti.

1. Looge Node.js projekt:

            mkdir api-testing-example
cd api-testing-example
npm init -y
            

              
                Copy
              
            
          

2. Installige sõltuvused:

            npm install --save-dev jest supertest
npm install express  # Or your preferred framework for creating the API
            

              
                Copy
              
            
          

3. Konfigureerige Jest: Lisage oma package.json faili järgnev:

            {
  "scripts": {
    "test": "jest"
  }
}
            

              
                Copy
              
            
          

4. Looge lihtne API lõpp-punkt: Looge fail nimega app.js (või sarnane) järgmise koodiga:

            const express = require('express');
const app = express();
const port = 3000;

app.get('/hello', (req, res) => {
  res.send('Hello, World!');
});

app.listen(port, () => {
  console.log(`Example app listening at http://localhost:${port}`);
});

module.exports = app; // Export for testing

            

              
                Copy
              
            
          

Esimese Supertesti testi kirjutamine

Nüüd, kui meie keskkond on seadistatud, kirjutame lihtsa Supertesti testi, et kontrollida meie API lõpp-punkti. Looge oma projekti juurkataloogi fail nimega app.test.js (või sarnane):

            const request = require('supertest');
const app = require('./app');

describe('GET /hello', () => {
  it('responds with 200 OK and returns "Hello, World!"', async () => {
    const response = await request(app).get('/hello');
    expect(response.statusCode).toBe(200);
    expect(response.text).toBe('Hello, World!');
  });
});

            

              
                Copy
              
            
          

Selgitus:

• Me impordime supertest'i ja oma Expressi rakenduse.
• Me kasutame describe'i oma testide grupeerimiseks.
• Me kasutame it'i konkreetse testjuhtumi defineerimiseks.
• Me kasutame request(app), et luua Supertesti agent, mis teeb päringuid meie rakendusele.
• Me kasutame .get('/hello'), et saata GET-päring /hello lõpp-punkti.
• Me kasutame await'i vastuse ootamiseks. Supertesti meetodid tagastavad lubadusi (promises), mis võimaldab meil puhtama koodi jaoks kasutada async/await süntaksit.
• Me kasutame expect(response.statusCode).toBe(200), et kinnitada, et vastuse olekukood on 200 OK.
• Me kasutame expect(response.text).toBe('Hello, World!'), et kinnitada, et vastuse keha on "Hello, World!".

Testi käivitamiseks käivitage terminalis järgmine käsk:

            npm test
            

              
                Copy
              
            
          

Kui kõik on õigesti seadistatud, peaksite nägema, et test läbib edukalt.

Supertesti täiustatud tehnikad

Supertest pakub laia valikut funktsioone täiustatud API testimiseks. Uurime mõnda neist.

1. Päringu kehade saatmine

Andmete saatmiseks päringu kehas saate kasutada .send() meetodit. Näiteks loome lõpp-punkti, mis aktsepteerib JSON-andmeid:

            app.post('/users', express.json(), (req, res) => {
  const { name, email } = req.body;
  // Simulate creating a user in a database
  const user = { id: Date.now(), name, email };
  res.status(201).json(user);
});
            

              
                Copy
              
            
          

Siin on, kuidas saate seda lõpp-punkti Supertestiga testida:

            describe('POST /users', () => {
  it('creates a new user', async () => {
    const userData = {
      name: 'John Doe',
      email: 'john.doe@example.com',
    };

    const response = await request(app)
      .post('/users')
      .send(userData)
      .expect(201);

    expect(response.body).toHaveProperty('id');
    expect(response.body.name).toBe(userData.name);
    expect(response.body.email).toBe(userData.email);
  });
});
            

              
                Copy
              
            
          

Selgitus:

• Me kasutame .post('/users'), et saata POST-päring /users lõpp-punkti.
• Me kasutame .send(userData), et saata userData objekt päringu kehas. Supertest seab automaatselt Content-Type päise väärtuseks application/json.
• Me kasutame .expect(201), et kinnitada, et vastuse olekukood on 201 Created.
• Me kasutame expect(response.body).toHaveProperty('id'), et kinnitada, et vastuse keha sisaldab id omadust.
• Me kasutame expect(response.body.name).toBe(userData.name) ja expect(response.body.email).toBe(userData.email), et kinnitada, et name ja email omadused vastuse kehas vastavad andmetele, mille me päringus saatsime.

2. Päiste seadistamine

Kohandatud päiste seadmiseks oma päringutes saate kasutada .set() meetodit. See on kasulik autentimislubade, sisutüüpide või muude kohandatud päiste seadistamiseks.

            describe('GET /protected', () => {
  it('requires authentication', async () => {
    const response = await request(app).get('/protected').expect(401);
  });

  it('returns 200 OK with a valid token', async () => {
    // Simulate getting a valid token
    const token = 'valid-token';

    const response = await request(app)
      .get('/protected')
      .set('Authorization', `Bearer ${token}`)
      .expect(200);

    expect(response.text).toBe('Protected Resource');
  });
});
            

              
                Copy
              
            
          

Selgitus:

• Me kasutame .set('Authorization', `Bearer ${token}`), et seada Authorization päise väärtuseks Bearer ${token}.

3. Küpsiste käsitlemine

Supertest saab hakkama ka küpsistega. Saate seada küpsiseid kasutades .set('Cookie', ...) meetodit või saate kasutada .cookies omadust küpsiste juurde pääsemiseks ja muutmiseks.

4. Failide üleslaadimise testimine

Supertesti saab kasutada failide üleslaadimist käsitlevate API lõpp-punktide testimiseks. Saate kasutada .attach() meetodit failide lisamiseks päringule.

5. Kinnitusteekide (Chai) kasutamine

Kuigi Jesti sisseehitatud kinnitusteek on paljudel juhtudel piisav, saate Supertestiga kasutada ka võimsamaid kinnitusteeke nagu Chai. Chai pakub väljendusrikkamat ja paindlikumat kinnitussüntaksit. Chai kasutamiseks peate selle installima:

            npm install --save-dev chai
            

              
                Copy
              
            
          

Seejärel saate Chai importida oma testfaili ja kasutada selle kinnitusi:

            const request = require('supertest');
const app = require('./app');
const chai = require('chai');
const expect = chai.expect;

describe('GET /hello', () => {
  it('responds with 200 OK and returns "Hello, World!"', async () => {
    const response = await request(app).get('/hello');
    expect(response.statusCode).to.equal(200);
    expect(response.text).to.equal('Hello, World!');
  });
});
            

              
                Copy
              
            
          

Märkus: Võimalik, et peate konfigureerima Jesti, et see töötaks Chai'ga korrektselt. See hõlmab sageli seadistusfaili lisamist, mis impordib Chai ja konfigureerib selle töötama Jesti globaalse expect'iga.

6. Agentide taaskasutamine

Testide jaoks, mis nõuavad spetsiifilise keskkonna seadistamist (nt autentimine), on sageli kasulik Supertesti agenti taaskasutada. See väldib üleliigset seadistuskoodi igas testjuhtumis.

            describe('Authenticated API Tests', () => {
  let agent;

  beforeAll(() => {
    agent = request.agent(app); // Create a persistent agent
    // Simulate authentication
    return agent
      .post('/login')
      .send({ username: 'testuser', password: 'password123' });
  });

  it('can access a protected resource', async () => {
    const response = await agent.get('/protected').expect(200);
    expect(response.text).toBe('Protected Resource');
  });

  it('can perform other actions that require authentication', async () => {
    // Perform other authenticated actions here
  });
});
            

              
                Copy
              
            
          

Selles näites loome beforeAll hook'is Supertesti agendi ja autendime agendi. Järgnevad testid describe ploki sees saavad seejärel seda autenditud agenti taaskasutada, ilma et peaksid iga testi jaoks uuesti autentima.

API integratsioonitestimise parimad tavad Supertestiga

Tõhusa API integratsioonitestimise tagamiseks kaaluge järgmisi parimaid tavasid:

• Testige täielikke töövoogusid: Keskenduge täielike kasutajate töövoogude testimisele, mitte isoleeritud API lõpp-punktidele. See aitab tuvastada integratsiooniprobleeme, mis ei pruugi ilmneda üksikute API-de eraldi testimisel.
• Kasutage realistlikke andmeid: Kasutage oma testides realistlikke andmeid, et simuleerida tegelikke stsenaariume. See hõlmab kehtivate andmevormingute, piirväärtuste ja potentsiaalselt kehtetute andmete kasutamist veakäsitluse testimiseks.
• Isoleerige oma testid: Veenduge, et teie testid on üksteisest sõltumatud ja ei tugine jagatud olekule. See muudab teie testid usaldusväärsemaks ja lihtsamini silutavaks. Kaaluge spetsiaalse testiandmebaasi kasutamist või väliste sõltuvuste jäljendamist (mocking).
• Jäljendage väliseid sõltuvusi: Kasutage jäljendamist (mocking), et isoleerida oma API välistest sõltuvustest, nagu andmebaasid, kolmandate osapoolte API-d või muud teenused. See muudab teie testid kiiremaks ja usaldusväärsemaks ning võimaldab teil testida erinevaid stsenaariume, ilma et peaksite tuginema väliste teenuste kättesaadavusele. Teegid nagu nock on kasulikud HTTP-päringute jäljendamiseks.
• Kirjutage põhjalikke teste: Püüdke saavutada põhjalik testide katvus, sealhulgas positiivsed testid (edukate vastuste kontrollimine), negatiivsed testid (veakäsitluse kontrollimine) ja piirtestide (äärmusjuhtumite kontrollimine).
• Automatiseerige oma testid: Integreerige oma API integratsioonitestid oma pideva integratsiooni (CI) torujuhtmesse, et tagada nende automaatne käivitamine iga kord, kui koodibaasis tehakse muudatusi. See aitab integratsiooniprobleeme varakult tuvastada ja vältida nende jõudmist tootmiskeskkonda.
• Dokumenteerige oma testid: Dokumenteerige oma API integratsioonitestid selgelt ja lühidalt. See muudab teistel arendajatel testide eesmärgi mõistmise ja nende hooldamise aja jooksul lihtsamaks.
• Kasutage keskkonnamuutujaid: Hoidke tundlikku teavet, nagu API-võtmed, andmebaasi paroolid ja muud konfiguratsiooniväärtused, keskkonnamuutujates, selle asemel et neid oma testidesse koodikirjutada. See muudab teie testid turvalisemaks ja lihtsamini konfigureeritavaks erinevate keskkondade jaoks.
• Kaaluge API lepinguid: Kasutage API lepingute testimist, et valideerida, kas teie API vastab määratletud lepingule (nt OpenAPI/Swagger). See aitab tagada ühilduvuse erinevate teenuste vahel ja vältida purustavaid muudatusi. Lepingute testimiseks saab kasutada tööriistu nagu Pact.

Levinumad vead, mida vältida

• Testide mitteisoleerimine: Testid peaksid olema sõltumatud. Vältige tuginemist teiste testide tulemustele.
• Implementatsiooni detailide testimine: Keskenduge API käitumisele ja lepingule, mitte selle sisemisele implementatsioonile.
• Veakäsitluse ignoreerimine: Testige põhjalikult, kuidas teie API käsitleb kehtetuid sisendeid, äärmusjuhtumeid ja ootamatuid vigu.
• Autentimise ja autoriseerimise testimise vahelejätmine: Veenduge, et teie API turvamehhanismid on korralikult testitud, et vältida volitamata juurdepääsu.

Kokkuvõte

API integratsioonitestimine on tarkvaraarendusprotsessi oluline osa. Supertesti abil saate hõlpsasti kirjutada põhjalikke ja usaldusväärseid API integratsiooniteste, mis aitavad tagada teie rakenduse kvaliteedi ja stabiilsuse. Ärge unustage keskenduda täielike töövoogude testimisele, realistlike andmete kasutamisele, testide isoleerimisele ja testimisprotsessi automatiseerimisele. Neid parimaid tavasid järgides saate oluliselt vähendada integratsiooniprobleemide riski ja pakkuda robustsemat ning usaldusväärsemat toodet.

Kuna API-d juhivad jätkuvalt kaasaegseid rakendusi ja mikroteenuste arhitektuure, kasvab robustse API testimise, eriti integratsioonitestimise, tähtsus veelgi. Supertest pakub arendajatele üle maailma võimsa ja kättesaadava tööriistakomplekti, et tagada oma API interaktsioonide usaldusväärsus ja kvaliteet.